home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet internetowy / Rozne / HTTrack 3.40-2 / httrack-3.40-2.exe / {app} / src / minizip / zip.c < prev    next >
C/C++ Source or Header  |  2005-09-24  |  37KB  |  1,200 lines
  1. /* zip.c -- IO on .zip files using zlib
  2.    Version 1.00, September 10th, 2003
  3.  
  4.    Copyright (C) 1998-2003 Gilles Vollant
  5.  
  6.    Read zip.h for more info
  7. */
  8.  
  9.  
  10. #ifndef _WIN32_WCE
  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #else
  14. #include <stdio.h>
  15. #include "celib.h"
  16. #endif
  17. #include <string.h>
  18. #include <time.h>
  19. #include "zlib.h"
  20. #include "zip.h"
  21.  
  22. #ifdef STDC
  23. #  include <stddef.h>
  24. #  include <string.h>
  25. #  include <stdlib.h>
  26. #endif
  27. #ifdef NO_ERRNO_H
  28.     extern int errno;
  29. #else
  30. #   include <errno.h>
  31. #endif
  32.  
  33.  
  34. #ifndef local
  35. #  define local static
  36. #endif
  37. /* compile with -Dlocal if your debugger can't find static symbols */
  38.  
  39. #ifndef VERSIONMADEBY
  40. # define VERSIONMADEBY   (0x0) /* platform depedent */
  41. #endif
  42.  
  43. #ifndef Z_BUFSIZE
  44. #define Z_BUFSIZE (16384)
  45. #endif
  46.  
  47. #ifndef Z_MAXFILENAMEINZIP
  48. #define Z_MAXFILENAMEINZIP (256)
  49. #endif
  50.  
  51. #ifndef ALLOC
  52. # define ALLOC(size) (malloc(size))
  53. #endif
  54. #ifndef TRYFREE
  55. # define TRYFREE(p) {if (p) free(p);}
  56. #endif
  57.  
  58. /*
  59. #define SIZECENTRALDIRITEM (0x2e)
  60. #define SIZEZIPLOCALHEADER (0x1e)
  61. */
  62.  
  63. /* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
  64.  
  65. #ifndef SEEK_CUR
  66. #define SEEK_CUR    1
  67. #endif
  68.  
  69. #ifndef SEEK_END
  70. #define SEEK_END    2
  71. #endif
  72.  
  73. #ifndef SEEK_SET
  74. #define SEEK_SET    0
  75. #endif
  76.  
  77. #ifndef DEF_MEM_LEVEL
  78. #if MAX_MEM_LEVEL >= 8
  79. #  define DEF_MEM_LEVEL 8
  80. #else
  81. #  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
  82. #endif
  83. #endif
  84. const char zip_copyright[] =
  85.    " zip 1.00 Copyright 1998-2003 Gilles Vollant - http://www.winimage.com/zLibDll";
  86.  
  87.  
  88. #define SIZEDATA_INDATABLOCK (4096-(4*4))
  89.  
  90. #define LOCALHEADERMAGIC    (0x04034b50)
  91. #define CENTRALHEADERMAGIC  (0x02014b50)
  92. #define ENDHEADERMAGIC      (0x06054b50)
  93.  
  94. #define FLAG_LOCALHEADER_OFFSET (0x06)
  95. #define CRC_LOCALHEADER_OFFSET  (0x0e)
  96.  
  97. #define SIZECENTRALHEADER (0x2e) /* 46 */
  98.  
  99. typedef struct linkedlist_datablock_internal_s
  100. {
  101.   struct linkedlist_datablock_internal_s* next_datablock;
  102.   uLong  avail_in_this_block;
  103.   uLong  filled_in_this_block;
  104.   uLong  unused; /* for future use and alignement */
  105.   unsigned char data[SIZEDATA_INDATABLOCK];
  106. } linkedlist_datablock_internal;
  107.  
  108. typedef struct linkedlist_data_s
  109. {
  110.     linkedlist_datablock_internal* first_block;
  111.     linkedlist_datablock_internal* last_block;
  112. } linkedlist_data;
  113.  
  114.  
  115. typedef struct
  116. {
  117.     z_stream stream;            /* zLib stream structure for inflate */
  118.     int  stream_initialised;    /* 1 is stream is initialised */
  119.     uInt pos_in_buffered_data;  /* last written byte in buffered_data */
  120.  
  121.     uLong pos_local_header;     /* offset of the local header of the file
  122.                                      currenty writing */
  123.     char* central_header;       /* central header data for the current file */
  124.     uLong size_centralheader;   /* size of the central header for cur file */
  125.     uLong flag;                 /* flag of the file currently writing */
  126.  
  127.     int  method;                /* compression method of file currenty wr.*/
  128.     int  raw;                   /* 1 for directly writing raw data */
  129.     Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/
  130.     uLong dosDate;
  131.     uLong crc32;
  132.     int  encrypt;
  133. #ifndef NOCRYPT
  134.     unsigned long keys[3];     /* keys defining the pseudo-random sequence */
  135.     const unsigned long* pcrc_32_tab;
  136.     int crypt_header_size;
  137. #endif
  138. } curfile_info;
  139.  
  140. typedef struct
  141. {
  142.     zlib_filefunc_def z_filefunc;
  143.     voidpf filestream;        /* io structore of the zipfile */
  144.     linkedlist_data central_dir;/* datablock with central dir in construction*/
  145.     int  in_opened_file_inzip;  /* 1 if a file in the zip is currently writ.*/
  146.     curfile_info ci;            /* info on the file curretly writing */
  147.  
  148.     uLong begin_pos;            /* position of the beginning of the zipfile */
  149.     uLong add_position_when_writting_offset;
  150.     uLong number_entry;
  151. } zip_internal;
  152.  
  153.  
  154.  
  155. #ifndef NOCRYPT
  156. #define INCLUDECRYPTINGCODE_IFCRYPTALLOWED
  157. #include "crypt.h"
  158. #endif
  159.  
  160. local linkedlist_datablock_internal* allocate_new_datablock()
  161. {
  162.     linkedlist_datablock_internal* ldi;
  163.     ldi = (linkedlist_datablock_internal*)
  164.                  ALLOC(sizeof(linkedlist_datablock_internal));
  165.     if (ldi!=NULL)
  166.     {
  167.         ldi->next_datablock = NULL ;
  168.         ldi->filled_in_this_block = 0 ;
  169.         ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ;
  170.     }
  171.     return ldi;
  172. }
  173.  
  174. local void free_datablock(ldi)
  175.     linkedlist_datablock_internal* ldi;
  176. {
  177.     while (ldi!=NULL)
  178.     {
  179.         linkedlist_datablock_internal* ldinext = ldi->next_datablock;
  180.         TRYFREE(ldi);
  181.         ldi = ldinext;
  182.     }
  183. }
  184.  
  185. local void init_linkedlist(ll)
  186.     linkedlist_data* ll;
  187. {
  188.     ll->first_block = ll->last_block = NULL;
  189. }
  190.  
  191. local void free_linkedlist(ll)
  192.     linkedlist_data* ll;
  193. {
  194.     free_datablock(ll->first_block);
  195.     ll->first_block = ll->last_block = NULL;
  196. }
  197.  
  198.  
  199. local int add_data_in_datablock(ll,buf,len)
  200.     linkedlist_data* ll;
  201.     const void* buf;
  202.     uLong len;
  203. {
  204.     linkedlist_datablock_internal* ldi;
  205.     const unsigned char* from_copy;
  206.  
  207.     if (ll==NULL)
  208.         return ZIP_INTERNALERROR;
  209.  
  210.     if (ll->last_block == NULL)
  211.     {
  212.         ll->first_block = ll->last_block = allocate_new_datablock();
  213.         if (ll->first_block == NULL)
  214.             return ZIP_INTERNALERROR;
  215.     }
  216.  
  217.     ldi = ll->last_block;
  218.     from_copy = (unsigned char*)buf;
  219.  
  220.     while (len>0)
  221.     {
  222.         uInt copy_this;
  223.         uInt i;
  224.         unsigned char* to_copy;
  225.  
  226.         if (ldi->avail_in_this_block==0)
  227.         {
  228.             ldi->next_datablock = allocate_new_datablock();
  229.             if (ldi->next_datablock == NULL)
  230.                 return ZIP_INTERNALERROR;
  231.             ldi = ldi->next_datablock ;
  232.             ll->last_block = ldi;
  233.         }
  234.  
  235.         if (ldi->avail_in_this_block < len)
  236.             copy_this = (uInt)ldi->avail_in_this_block;
  237.         else
  238.             copy_this = (uInt)len;
  239.  
  240.         to_copy = &(ldi->data[ldi->filled_in_this_block]);
  241.  
  242.         for (i=0;i<copy_this;i++)
  243.             *(to_copy+i)=*(from_copy+i);
  244.  
  245.         ldi->filled_in_this_block += copy_this;
  246.         ldi->avail_in_this_block -= copy_this;
  247.         from_copy += copy_this ;
  248.         len -= copy_this;
  249.     }
  250.     return ZIP_OK;
  251. }
  252.  
  253.  
  254.  
  255. /****************************************************************************/
  256.  
  257. #ifndef NO_ADDFILEINEXISTINGZIP
  258. /* ===========================================================================
  259.    Inputs a long in LSB order to the given file
  260.    nbByte == 1, 2 or 4 (byte, short or long)
  261. */
  262.  
  263. local int ziplocal_putValue OF((const zlib_filefunc_def* pzlib_filefunc_def,
  264.                                 voidpf filestream, uLong x, int nbByte));
  265. local int ziplocal_putValue (pzlib_filefunc_def, filestream, x, nbByte)
  266.     const zlib_filefunc_def* pzlib_filefunc_def;
  267.     voidpf filestream;
  268.     uLong x;
  269.     int nbByte;
  270. {
  271.     unsigned char buf[4];
  272.     int n;
  273.     for (n = 0; n < nbByte; n++) {
  274.         buf[n] = (unsigned char)(x & 0xff);
  275.         x >>= 8;
  276.     }
  277.     if (x != 0) {     // data overflow - hack for ZIP64
  278.       for (n = 0; n < nbByte; n++) {
  279.         buf[n] = 0xff;
  280.       }
  281.     }
  282.    if (ZWRITE(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte)
  283.         return ZIP_ERRNO;
  284.     else
  285.         return ZIP_OK;
  286. }
  287.  
  288. local void ziplocal_putValue_inmemory OF((void* dest, uLong x, int nbByte));
  289. local void ziplocal_putValue_inmemory (dest, x, nbByte)
  290.     void* dest;
  291.     uLong x;
  292.     int nbByte;
  293. {
  294.     unsigned char* buf=(unsigned char*)dest;
  295.     int n;
  296.     for (n = 0; n < nbByte; n++) {
  297.         buf[n] = (unsigned char)(x & 0xff);
  298.         x >>= 8;
  299.     }
  300.     if (x != 0) {     // data overflow - hack for ZIP64
  301.       for (n = 0; n < nbByte; n++) {
  302.         buf[n] = 0xff;
  303.       }
  304.     }
  305. }
  306. /****************************************************************************/
  307.  
  308.  
  309. local uLong ziplocal_TmzDateToDosDate(ptm,dosDate)
  310.     const tm_zip* ptm;
  311.     uLong dosDate;
  312. {
  313.     uLong year = (uLong)ptm->tm_year;
  314.     if (year>1980)
  315.         year-=1980;
  316.     else if (year>80)
  317.         year-=80;
  318.     return
  319.       (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) |
  320.         ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour));
  321. }
  322.  
  323.  
  324. /****************************************************************************/
  325.  
  326. local int ziplocal_getByte OF((
  327.     const zlib_filefunc_def* pzlib_filefunc_def,
  328.     voidpf filestream,
  329.     int *pi));
  330.  
  331. local int ziplocal_getByte(pzlib_filefunc_def,filestream,pi)
  332.     const zlib_filefunc_def* pzlib_filefunc_def;
  333.     voidpf filestream;
  334.     int *pi;
  335. {
  336.     unsigned char c;
  337.     int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
  338.     if (err==1)
  339.     {
  340.         *pi = (int)c;
  341.         return ZIP_OK;
  342.     }
  343.     else
  344.     {
  345.         if (ZERROR(*pzlib_filefunc_def,filestream))
  346.             return ZIP_ERRNO;
  347.         else
  348.             return ZIP_EOF;
  349.     }
  350. }
  351.  
  352.  
  353. /* ===========================================================================
  354.    Reads a long in LSB order from the given gz_stream. Sets
  355. */
  356. local int ziplocal_getShort OF((
  357.     const zlib_filefunc_def* pzlib_filefunc_def,
  358.     voidpf filestream,
  359.     uLong *pX));
  360.  
  361. local int ziplocal_getShort (pzlib_filefunc_def,filestream,pX)
  362.     const zlib_filefunc_def* pzlib_filefunc_def;
  363.     voidpf filestream;
  364.     uLong *pX;
  365. {
  366.     uLong x ;
  367.     int i;
  368.     int err;
  369.  
  370.     err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
  371.     x = (uLong)i;
  372.  
  373.     if (err==ZIP_OK)
  374.         err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
  375.     x += ((uLong)i)<<8;
  376.  
  377.     if (err==ZIP_OK)
  378.         *pX = x;
  379.     else
  380.         *pX = 0;
  381.     return err;
  382. }
  383.  
  384. local int ziplocal_getLong OF((
  385.     const zlib_filefunc_def* pzlib_filefunc_def,
  386.     voidpf filestream,
  387.     uLong *pX));
  388.  
  389. local int ziplocal_getLong (pzlib_filefunc_def,filestream,pX)
  390.     const zlib_filefunc_def* pzlib_filefunc_def;
  391.     voidpf filestream;
  392.     uLong *pX;
  393. {
  394.     uLong x ;
  395.     int i;
  396.     int err;
  397.  
  398.     err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
  399.     x = (uLong)i;
  400.  
  401.     if (err==ZIP_OK)
  402.         err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
  403.     x += ((uLong)i)<<8;
  404.  
  405.     if (err==ZIP_OK)
  406.         err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
  407.     x += ((uLong)i)<<16;
  408.  
  409.     if (err==ZIP_OK)
  410.         err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
  411.     x += ((uLong)i)<<24;
  412.  
  413.     if (err==ZIP_OK)
  414.         *pX = x;
  415.     else
  416.         *pX = 0;
  417.     return err;
  418. }
  419.  
  420. #ifndef BUFREADCOMMENT
  421. #define BUFREADCOMMENT (0x400)
  422. #endif
  423. /*
  424.   Locate the Central directory of a zipfile (at the end, just before
  425.     the global comment)
  426. */
  427. local uLong ziplocal_SearchCentralDir OF((
  428.     const zlib_filefunc_def* pzlib_filefunc_def,
  429.     voidpf filestream));
  430.  
  431. local uLong ziplocal_SearchCentralDir(pzlib_filefunc_def,filestream)
  432.     const zlib_filefunc_def* pzlib_filefunc_def;
  433.     voidpf filestream;
  434. {
  435.     unsigned char* buf;
  436.     uLong uSizeFile;
  437.     uLong uBackRead;
  438.     uLong uMaxBack=0xffff; /* maximum size of global comment */
  439.     uLong uPosFound=0;
  440.  
  441.     if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
  442.         return 0;
  443.  
  444.  
  445.     uSizeFile = ZTELL(*pzlib_filefunc_def,filestream);
  446.  
  447.     if (uMaxBack>uSizeFile)
  448.         uMaxBack = uSizeFile;
  449.  
  450.     buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
  451.     if (buf==NULL)
  452.         return 0;
  453.  
  454.     uBackRead = 4;
  455.     while (uBackRead<uMaxBack)
  456.     {
  457.         uLong uReadSize,uReadPos ;
  458.         int i;
  459.         if (uBackRead+BUFREADCOMMENT>uMaxBack)
  460.             uBackRead = uMaxBack;
  461.         else
  462.             uBackRead+=BUFREADCOMMENT;
  463.         uReadPos = uSizeFile-uBackRead ;
  464.  
  465.         uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
  466.                      (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
  467.         if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
  468.             break;
  469.  
  470.         if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
  471.             break;
  472.  
  473.         for (i=(int)uReadSize-3; (i--)>0;)
  474.             if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
  475.                 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
  476.             {
  477.                 uPosFound = uReadPos+i;
  478.                 break;
  479.             }
  480.  
  481.         if (uPosFound!=0)
  482.             break;
  483.     }
  484.     TRYFREE(buf);
  485.     return uPosFound;
  486. }
  487. #endif /* !NO_ADDFILEINEXISTINGZIP*/
  488.  
  489. /************************************************************/
  490. extern zipFile ZEXPORT zipOpen2 (pathname, append, globalcomment, pzlib_filefunc_def)
  491.     const char *pathname;
  492.     int append;
  493.     zipcharpc* globalcomment;
  494.     zlib_filefunc_def* pzlib_filefunc_def;
  495. {
  496.     zip_internal ziinit;
  497.     zip_internal* zi;
  498.     int err=ZIP_OK;
  499.  
  500.  
  501.     if (pzlib_filefunc_def==NULL)
  502.         fill_fopen_filefunc(&ziinit.z_filefunc);
  503.     else
  504.         ziinit.z_filefunc = *pzlib_filefunc_def;
  505.  
  506.     ziinit.filestream = (*(ziinit.z_filefunc.zopen_file))
  507.                  (ziinit.z_filefunc.opaque,
  508.                   pathname,
  509.                   (append == APPEND_STATUS_CREATE) ?
  510.                   (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) :
  511.                     (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING));
  512.  
  513.     if (ziinit.filestream == NULL)
  514.         return NULL;
  515.     ziinit.begin_pos = ZTELL(ziinit.z_filefunc,ziinit.filestream);
  516.     ziinit.in_opened_file_inzip = 0;
  517.     ziinit.ci.stream_initialised = 0;
  518.     ziinit.number_entry = 0;
  519.     ziinit.add_position_when_writting_offset = 0;
  520.     init_linkedlist(&(ziinit.central_dir));
  521.  
  522.  
  523.     zi = (zip_internal*)ALLOC(sizeof(zip_internal));
  524.     if (zi==NULL)
  525.     {
  526.         ZCLOSE(ziinit.z_filefunc,ziinit.filestream);
  527.         return NULL;
  528.     }
  529.  
  530.     /* now we add file in a zipfile */
  531. #    ifndef NO_ADDFILEINEXISTINGZIP
  532.     if (append == APPEND_STATUS_ADDINZIP)
  533.     {
  534.         uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
  535.  
  536.         uLong size_central_dir;     /* size of the central directory  */
  537.         uLong offset_central_dir;   /* offset of start of central directory */
  538.         uLong central_pos,uL;
  539.  
  540.         uLong number_disk;          /* number of the current dist, used for
  541.                                     spaning ZIP, unsupported, always 0*/
  542.         uLong number_disk_with_CD;  /* number the the disk with central dir, used
  543.                                     for spaning ZIP, unsupported, always 0*/
  544.         uLong number_entry;
  545.         uLong number_entry_CD;      /* total number of entries in
  546.                                     the central dir
  547.                                     (same than number_entry on nospan) */
  548.         uLong size_comment;
  549.  
  550.         central_pos = ziplocal_SearchCentralDir(&ziinit.z_filefunc,ziinit.filestream);
  551.         if (central_pos==0)
  552.             err=ZIP_ERRNO;
  553.  
  554.         if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
  555.                                         central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
  556.             err=ZIP_ERRNO;
  557.  
  558.         /* the signature, already checked */
  559.         if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&uL)!=ZIP_OK)
  560.             err=ZIP_ERRNO;
  561.  
  562.         /* number of this disk */
  563.         if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk)!=ZIP_OK)
  564.             err=ZIP_ERRNO;
  565.  
  566.         /* number of the disk with the start of the central directory */
  567.         if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk_with_CD)!=ZIP_OK)
  568.             err=ZIP_ERRNO;
  569.  
  570.         /* total number of entries in the central dir on this disk */
  571.         if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry)!=ZIP_OK)
  572.             err=ZIP_ERRNO;
  573.  
  574.         /* total number of entries in the central dir */
  575.         if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry_CD)!=ZIP_OK)
  576.             err=ZIP_ERRNO;
  577.  
  578.         if ((number_entry_CD!=number_entry) ||
  579.             (number_disk_with_CD!=0) ||
  580.             (number_disk!=0))
  581.             err=ZIP_BADZIPFILE;
  582.  
  583.         /* size of the central directory */
  584.         if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&size_central_dir)!=ZIP_OK)
  585.             err=ZIP_ERRNO;
  586.  
  587.         /* offset of start of central directory with respect to the
  588.             starting disk number */
  589.         if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&offset_central_dir)!=ZIP_OK)
  590.             err=ZIP_ERRNO;
  591.  
  592.         /* zipfile comment length */
  593.         if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&size_comment)!=ZIP_OK)
  594.             err=ZIP_ERRNO;
  595.  
  596.         if ((central_pos<offset_central_dir+size_central_dir) &&
  597.             (err==ZIP_OK))
  598.             err=ZIP_BADZIPFILE;
  599.  
  600.         if (err!=ZIP_OK)
  601.         {
  602.             ZCLOSE(ziinit.z_filefunc, ziinit.filestream);
  603.             return NULL;
  604.         }
  605.  
  606.         byte_before_the_zipfile = central_pos -
  607.                                 (offset_central_dir+size_central_dir);
  608.         ziinit.add_position_when_writting_offset = byte_before_the_zipfile ;
  609.  
  610.         {
  611.             uLong size_central_dir_to_read = size_central_dir;
  612.             size_t buf_size = SIZEDATA_INDATABLOCK;
  613.             void* buf_read = (void*)ALLOC(buf_size);
  614.             if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
  615.                   offset_central_dir + byte_before_the_zipfile,
  616.                   ZLIB_FILEFUNC_SEEK_SET) != 0)
  617.                   err=ZIP_ERRNO;
  618.  
  619.             while ((size_central_dir_to_read>0) && (err==ZIP_OK))
  620.             {
  621.                 uLong read_this = SIZEDATA_INDATABLOCK;
  622.                 if (read_this > size_central_dir_to_read)
  623.                     read_this = size_central_dir_to_read;
  624.                 if (ZREAD(ziinit.z_filefunc, ziinit.filestream,buf_read,read_this) != read_this)
  625.                     err=ZIP_ERRNO;
  626.  
  627.                 if (err==ZIP_OK)
  628.                     err = add_data_in_datablock(&ziinit.central_dir,buf_read,
  629.                                                 (uLong)read_this);
  630.                 size_central_dir_to_read-=read_this;
  631.             }
  632.             TRYFREE(buf_read);
  633.         }
  634.         ziinit.begin_pos = byte_before_the_zipfile;
  635.         ziinit.number_entry = number_entry_CD;
  636.  
  637.         if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
  638.                   offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
  639.             err=ZIP_ERRNO;
  640.     }
  641. #    endif /* !NO_ADDFILEINEXISTINGZIP*/
  642.  
  643.     if (err != ZIP_OK)
  644.     {
  645.         TRYFREE(zi);
  646.         return NULL;
  647.     }
  648.     else
  649.     {
  650.         *zi = ziinit;
  651.         return (zipFile)zi;
  652.     }
  653. }
  654.  
  655. extern zipFile ZEXPORT zipOpen (pathname, append)
  656.     const char *pathname;
  657.     int append;
  658. {
  659.     return zipOpen2(pathname,append,NULL,NULL);
  660. }
  661.  
  662. extern int ZEXPORT zipOpenNewFileInZip3 (file, filename, zipfi,
  663.                                          extrafield_local, size_extrafield_local,
  664.                                          extrafield_global, size_extrafield_global,
  665.                                          comment, method, level, raw,
  666.                                          windowBits, memLevel, strategy,
  667.                                          password, crcForCrypting)
  668.     zipFile file;
  669.     const char* filename;
  670.     const zip_fileinfo* zipfi;
  671.     const void* extrafield_local;
  672.     uInt size_extrafield_local;
  673.     const void* extrafield_global;
  674.     uInt size_extrafield_global;
  675.     const char* comment;
  676.     int method;
  677.     int level;
  678.     int raw;
  679.     int windowBits;
  680.     int memLevel;
  681.     int strategy;
  682.     const char* password;
  683.     uLong crcForCrypting;
  684. {
  685.     zip_internal* zi;
  686.     uInt size_filename;
  687.     uInt size_comment;
  688.     uInt i;
  689.     int err = ZIP_OK;
  690.  
  691. #    ifdef NOCRYPT
  692.     if (password != NULL)
  693.         return ZIP_PARAMERROR;
  694. #    endif
  695.  
  696.     if (file == NULL)
  697.         return ZIP_PARAMERROR;
  698.     if ((method!=0) && (method!=Z_DEFLATED))
  699.         return ZIP_PARAMERROR;
  700.  
  701.     zi = (zip_internal*)file;
  702.  
  703.     if (zi->in_opened_file_inzip == 1)
  704.     {
  705.         err = zipCloseFileInZip (file);
  706.         if (err != ZIP_OK)
  707.             return err;
  708.     }
  709.  
  710.  
  711.     if (filename==NULL)
  712.         filename="-";
  713.  
  714.     if (comment==NULL)
  715.         size_comment = 0;
  716.     else
  717.         size_comment = strlen(comment);
  718.  
  719.     size_filename = strlen(filename);
  720.  
  721.     if (zipfi == NULL)
  722.         zi->ci.dosDate = 0;
  723.     else
  724.     {
  725.         if (zipfi->dosDate != 0)
  726.             zi->ci.dosDate = zipfi->dosDate;
  727.         else zi->ci.dosDate = ziplocal_TmzDateToDosDate(&zipfi->tmz_date,zipfi->dosDate);
  728.     }
  729.  
  730.     zi->ci.flag = 0;
  731.     if ((level==8) || (level==9))
  732.       zi->ci.flag |= 2;
  733.     if ((level==2))
  734.       zi->ci.flag |= 4;
  735.     if ((level==1))
  736.       zi->ci.flag |= 6;
  737.     if (password != NULL)
  738.       zi->ci.flag |= 1;
  739.  
  740.     zi->ci.crc32 = 0;
  741.     zi->ci.method = method;
  742.     zi->ci.encrypt = 0;
  743.     zi->ci.stream_initialised = 0;
  744.     zi->ci.pos_in_buffered_data = 0;
  745.     zi->ci.raw = raw;
  746.     zi->ci.pos_local_header = ZTELL(zi->z_filefunc,zi->filestream) ;
  747.     zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename +
  748.                                       size_extrafield_global + size_comment;
  749.     zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader);
  750.  
  751.     ziplocal_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4);
  752.     /* version info */
  753.     ziplocal_putValue_inmemory(zi->ci.central_header+4,(uLong)VERSIONMADEBY,2);
  754.     ziplocal_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2);
  755.     ziplocal_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2);
  756.     ziplocal_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2);
  757.     ziplocal_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4);
  758.     ziplocal_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/
  759.     ziplocal_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/
  760.     ziplocal_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/
  761.     ziplocal_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2);
  762.     ziplocal_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2);
  763.     ziplocal_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2);
  764.     ziplocal_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/
  765.  
  766.     if (zipfi==NULL)
  767.         ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2);
  768.     else
  769.         ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2);
  770.  
  771.     if (zipfi==NULL)
  772.         ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4);
  773.     else
  774.         ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4);
  775.  
  776.     ziplocal_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header- zi->add_position_when_writting_offset,4);
  777.  
  778.     for (i=0;i<size_filename;i++)
  779.         *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i);
  780.  
  781.     for (i=0;i<size_extrafield_global;i++)
  782.         *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) =
  783.               *(((const char*)extrafield_global)+i);
  784.  
  785.     for (i=0;i<size_comment;i++)
  786.         *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+
  787.               size_extrafield_global+i) = *(comment+i);
  788.     if (zi->ci.central_header == NULL)
  789.         return ZIP_INTERNALERROR;
  790.  
  791.     /* write the local header */
  792.     err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC,4);
  793.  
  794.     if (err==ZIP_OK)
  795.         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */
  796.     if (err==ZIP_OK)
  797.         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2);
  798.  
  799.     if (err==ZIP_OK)
  800.         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2);
  801.  
  802.     if (err==ZIP_OK)
  803.         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4);
  804.  
  805.     if (err==ZIP_OK)
  806.         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */
  807.     if (err==ZIP_OK)
  808.         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */
  809.     if (err==ZIP_OK)
  810.         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */
  811.  
  812.     if (err==ZIP_OK)
  813.         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2);
  814.  
  815.     if (err==ZIP_OK)
  816.         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield_local,2);
  817.  
  818.     if ((err==ZIP_OK) && (size_filename>0))
  819.         if (ZWRITE(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename)
  820.                 err = ZIP_ERRNO;
  821.  
  822.     if ((err==ZIP_OK) && (size_extrafield_local>0))
  823.         if (ZWRITE(zi->z_filefunc,zi->filestream,extrafield_local,size_extrafield_local)
  824.                                                                            !=size_extrafield_local)
  825.                 err = ZIP_ERRNO;
  826.  
  827.     zi->ci.stream.avail_in = (uInt)0;
  828.     zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
  829.     zi->ci.stream.next_out = zi->ci.buffered_data;
  830.     zi->ci.stream.total_in = 0;
  831.     zi->ci.stream.total_out = 0;
  832.  
  833.     if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
  834.     {
  835.         zi->ci.stream.zalloc = (alloc_func)0;
  836.         zi->ci.stream.zfree = (free_func)0;
  837.         zi->ci.stream.opaque = (voidpf)0;
  838.  
  839.         if (windowBits>0)
  840.             windowBits = -windowBits;
  841.  
  842.         err = deflateInit2(&zi->ci.stream, level,
  843.                Z_DEFLATED, windowBits, memLevel, strategy);
  844.  
  845.         if (err==Z_OK)
  846.             zi->ci.stream_initialised = 1;
  847.     }
  848. #    ifndef NOCRYPT
  849.     zi->ci.crypt_header_size = 0;
  850.     if ((err==Z_OK) && (password != NULL))
  851.     {
  852.         unsigned char bufHead[RAND_HEAD_LEN];
  853.         unsigned int sizeHead;
  854.         zi->ci.encrypt = 1;
  855.         zi->ci.pcrc_32_tab = get_crc_table();
  856.         /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/
  857.  
  858.         sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting);
  859.         zi->ci.crypt_header_size = sizeHead;
  860.  
  861.         if (ZWRITE(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead)
  862.                 err = ZIP_ERRNO;
  863.     }
  864. #    endif
  865.  
  866.     if (err==Z_OK)
  867.         zi->in_opened_file_inzip = 1;
  868.     return err;
  869. }
  870.  
  871. extern int ZEXPORT zipOpenNewFileInZip2(file, filename, zipfi,
  872.                                         extrafield_local, size_extrafield_local,
  873.                                         extrafield_global, size_extrafield_global,
  874.                                         comment, method, level, raw)
  875.     zipFile file;
  876.     const char* filename;
  877.     const zip_fileinfo* zipfi;
  878.     const void* extrafield_local;
  879.     uInt size_extrafield_local;
  880.     const void* extrafield_global;
  881.     uInt size_extrafield_global;
  882.     const char* comment;
  883.     int method;
  884.     int level;
  885.     int raw;
  886. {
  887.     return zipOpenNewFileInZip3 (file, filename, zipfi,
  888.                                  extrafield_local, size_extrafield_local,
  889.                                  extrafield_global, size_extrafield_global,
  890.                                  comment, method, level, raw,
  891.                                  -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
  892.                                  NULL, 0);
  893. }
  894.  
  895. extern int ZEXPORT zipOpenNewFileInZip (file, filename, zipfi,
  896.                                         extrafield_local, size_extrafield_local,
  897.                                         extrafield_global, size_extrafield_global,
  898.                                         comment, method, level)
  899.     zipFile file;
  900.     const char* filename;
  901.     const zip_fileinfo* zipfi;
  902.     const void* extrafield_local;
  903.     uInt size_extrafield_local;
  904.     const void* extrafield_global;
  905.     uInt size_extrafield_global;
  906.     const char* comment;
  907.     int method;
  908.     int level;
  909. {
  910.     return zipOpenNewFileInZip2 (file, filename, zipfi,
  911.                                  extrafield_local, size_extrafield_local,
  912.                                  extrafield_global, size_extrafield_global,
  913.                                  comment, method, level, 0);
  914. }
  915.  
  916. local int zipFlushWriteBuffer(zi)
  917.   zip_internal* zi;
  918. {
  919.     int err=ZIP_OK;
  920.  
  921.     if (zi->ci.encrypt != 0)
  922.     {
  923. #ifndef NOCRYPT
  924.         uInt i;
  925.         int t;
  926.         for (i=0;i<zi->ci.pos_in_buffered_data;i++)
  927.             zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab,
  928.                                        zi->ci.buffered_data[i],t);
  929. #endif
  930.     }
  931.     if (ZWRITE(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data)
  932.                                                                     !=zi->ci.pos_in_buffered_data)
  933.       err = ZIP_ERRNO;
  934.     zi->ci.pos_in_buffered_data = 0;
  935.     return err;
  936. }
  937.  
  938. extern int ZEXPORT zipWriteInFileInZip (file, buf, len)
  939.     zipFile file;
  940.     const void* buf;
  941.     unsigned len;
  942. {
  943.     zip_internal* zi;
  944.     int err=ZIP_OK;
  945.  
  946.     if (file == NULL)
  947.         return ZIP_PARAMERROR;
  948.     zi = (zip_internal*)file;
  949.  
  950.     if (zi->in_opened_file_inzip == 0)
  951.         return ZIP_PARAMERROR;
  952.  
  953.     zi->ci.stream.next_in = (void*)buf;
  954.     zi->ci.stream.avail_in = len;
  955.     zi->ci.crc32 = crc32(zi->ci.crc32,buf,len);
  956.  
  957.     while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0))
  958.     {
  959.         if (zi->ci.stream.avail_out == 0)
  960.         {
  961.             if (zipFlushWriteBuffer(zi) == ZIP_ERRNO)
  962.                 err = ZIP_ERRNO;
  963.             zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
  964.             zi->ci.stream.next_out = zi->ci.buffered_data;
  965.         }
  966.  
  967.  
  968.         if(err != ZIP_OK)
  969.             break;
  970.  
  971.         if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
  972.         {
  973.             uLong uTotalOutBefore = zi->ci.stream.total_out;
  974.             err=deflate(&zi->ci.stream,  Z_NO_FLUSH);
  975.             zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
  976.  
  977.         }
  978.         else
  979.         {
  980.             uInt copy_this,i;
  981.             if (zi->ci.stream.avail_in < zi->ci.stream.avail_out)
  982.                 copy_this = zi->ci.stream.avail_in;
  983.             else
  984.                 copy_this = zi->ci.stream.avail_out;
  985.             for (i=0;i<copy_this;i++)
  986.                 *(((char*)zi->ci.stream.next_out)+i) =
  987.                     *(((const char*)zi->ci.stream.next_in)+i);
  988.             {
  989.                 zi->ci.stream.avail_in -= copy_this;
  990.                 zi->ci.stream.avail_out-= copy_this;
  991.                 zi->ci.stream.next_in+= copy_this;
  992.                 zi->ci.stream.next_out+= copy_this;
  993.                 zi->ci.stream.total_in+= copy_this;
  994.                 zi->ci.stream.total_out+= copy_this;
  995.                 zi->ci.pos_in_buffered_data += copy_this;
  996.             }
  997.         }
  998.     }
  999.  
  1000.     return err;
  1001. }
  1002.  
  1003. extern int ZEXPORT zipCloseFileInZipRaw (file, uncompressed_size, crc32)
  1004.     zipFile file;
  1005.     uLong uncompressed_size;
  1006.     uLong crc32;
  1007. {
  1008.     zip_internal* zi;
  1009.     uLong compressed_size;
  1010.     int err=ZIP_OK;
  1011.  
  1012.     if (file == NULL)
  1013.         return ZIP_PARAMERROR;
  1014.     zi = (zip_internal*)file;
  1015.  
  1016.     if (zi->in_opened_file_inzip == 0)
  1017.         return ZIP_PARAMERROR;
  1018.     zi->ci.stream.avail_in = 0;
  1019.  
  1020.     if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
  1021.         while (err==ZIP_OK)
  1022.     {
  1023.         uLong uTotalOutBefore;
  1024.         if (zi->ci.stream.avail_out == 0)
  1025.         {
  1026.             if (zipFlushWriteBuffer(zi) == ZIP_ERRNO)
  1027.                 err = ZIP_ERRNO;
  1028.             zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
  1029.             zi->ci.stream.next_out = zi->ci.buffered_data;
  1030.         }
  1031.         uTotalOutBefore = zi->ci.stream.total_out;
  1032.         err=deflate(&zi->ci.stream,  Z_FINISH);
  1033.         zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
  1034.     }
  1035.  
  1036.     if (err==Z_STREAM_END)
  1037.         err=ZIP_OK; /* this is normal */
  1038.  
  1039.     if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK))
  1040.         if (zipFlushWriteBuffer(zi)==ZIP_ERRNO)
  1041.             err = ZIP_ERRNO;
  1042.  
  1043.     if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
  1044.     {
  1045.         err=deflateEnd(&zi->ci.stream);
  1046.         zi->ci.stream_initialised = 0;
  1047.     }
  1048.  
  1049.     if (!zi->ci.raw)
  1050.     {
  1051.         crc32 = (uLong)zi->ci.crc32;
  1052.         uncompressed_size = (uLong)zi->ci.stream.total_in;
  1053.     }
  1054.     compressed_size = (uLong)zi->ci.stream.total_out;
  1055. #    ifndef NOCRYPT
  1056.     compressed_size += zi->ci.crypt_header_size;
  1057. #    endif
  1058.  
  1059.     ziplocal_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/
  1060.     ziplocal_putValue_inmemory(zi->ci.central_header+20,
  1061.                                 compressed_size,4); /*compr size*/
  1062.     if (zi->ci.stream.data_type == Z_ASCII)
  1063.         ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2);
  1064.     ziplocal_putValue_inmemory(zi->ci.central_header+24,
  1065.                                 uncompressed_size,4); /*uncompr size*/
  1066.  
  1067.     if (err==ZIP_OK)
  1068.         err = add_data_in_datablock(&zi->central_dir,zi->ci.central_header,
  1069.                                        (uLong)zi->ci.size_centralheader);
  1070.     free(zi->ci.central_header);
  1071.  
  1072.     if (err==ZIP_OK)
  1073.     {
  1074.         long cur_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream);
  1075.         if (ZSEEK(zi->z_filefunc,zi->filestream,
  1076.                   zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0)
  1077.             err = ZIP_ERRNO;
  1078.  
  1079.         if (err==ZIP_OK)
  1080.             err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */
  1081.  
  1082.         if (err==ZIP_OK) /* compressed size, unknown */
  1083.             err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4);
  1084.  
  1085.         if (err==ZIP_OK) /* uncompressed size, unknown */
  1086.             err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4);
  1087.  
  1088.         if (ZSEEK(zi->z_filefunc,zi->filestream,
  1089.                   cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0)
  1090.             err = ZIP_ERRNO;
  1091.     }
  1092.  
  1093.     zi->number_entry ++;
  1094.     zi->in_opened_file_inzip = 0;
  1095.  
  1096.     return err;
  1097. }
  1098.  
  1099. extern int ZEXPORT zipCloseFileInZip (file)
  1100.     zipFile file;
  1101. {
  1102.     return zipCloseFileInZipRaw (file,0,0);
  1103. }
  1104.  
  1105. extern int ZEXPORT zipClose (file, global_comment)
  1106.     zipFile file;
  1107.     const char* global_comment;
  1108. {
  1109.     zip_internal* zi;
  1110.     int err = 0;
  1111.     uLong size_centraldir = 0;
  1112.     uLong centraldir_pos_inzip ;
  1113.     uInt size_global_comment;
  1114.     if (file == NULL)
  1115.         return ZIP_PARAMERROR;
  1116.     zi = (zip_internal*)file;
  1117.  
  1118.     if (zi->in_opened_file_inzip == 1)
  1119.     {
  1120.         err = zipCloseFileInZip (file);
  1121.     }
  1122.  
  1123.     if (global_comment==NULL)
  1124.         size_global_comment = 0;
  1125.     else
  1126.         size_global_comment = strlen(global_comment);
  1127.  
  1128.  
  1129.     centraldir_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream);
  1130.     if (err==ZIP_OK)
  1131.     {
  1132.         linkedlist_datablock_internal* ldi = zi->central_dir.first_block ;
  1133.         while (ldi!=NULL)
  1134.         {
  1135.             if ((err==ZIP_OK) && (ldi->filled_in_this_block>0))
  1136.                 if (ZWRITE(zi->z_filefunc,zi->filestream,
  1137.                            ldi->data,ldi->filled_in_this_block)
  1138.                               !=ldi->filled_in_this_block )
  1139.                     err = ZIP_ERRNO;
  1140.  
  1141.             size_centraldir += ldi->filled_in_this_block;
  1142.             ldi = ldi->next_datablock;
  1143.         }
  1144.     }
  1145.     free_datablock(zi->central_dir.first_block);
  1146.  
  1147.     if (err==ZIP_OK) /* Magic End */
  1148.         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4);
  1149.  
  1150.     if (err==ZIP_OK) /* number of this disk */
  1151.         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
  1152.  
  1153.     if (err==ZIP_OK) /* number of the disk with the start of the central directory */
  1154.         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
  1155.  
  1156.     if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
  1157.         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
  1158.  
  1159.     if (err==ZIP_OK) /* total number of entries in the central dir */
  1160.         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
  1161.  
  1162.     if (err==ZIP_OK) /* size of the central directory */
  1163.         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4);
  1164.  
  1165.     if (err==ZIP_OK) /* offset of start of central directory with respect to the
  1166.                             starting disk number */
  1167.         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,
  1168.                                 (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4);
  1169.  
  1170.     if (err==ZIP_OK) /* zipfile comment length */
  1171.         err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2);
  1172.  
  1173.     if ((err==ZIP_OK) && (size_global_comment>0))
  1174.         if (ZWRITE(zi->z_filefunc,zi->filestream,
  1175.                    global_comment,size_global_comment) != size_global_comment)
  1176.                 err = ZIP_ERRNO;
  1177.  
  1178.     if (ZCLOSE(zi->z_filefunc,zi->filestream) != 0)
  1179.         if (err == ZIP_OK)
  1180.             err = ZIP_ERRNO;
  1181.  
  1182.     TRYFREE(zi);
  1183.  
  1184.     return err;
  1185. }
  1186.  
  1187. extern int ZEXPORT zipFlush (file)
  1188.     zipFile file;
  1189. {
  1190.     zip_internal* zi;
  1191.     if (file == NULL)
  1192.         return ZIP_PARAMERROR;
  1193.     zi = (zip_internal*)file;
  1194.  
  1195.     if (zi->z_filefunc.zflush_file != NULL && zi->filestream != NULL)
  1196.       return ZFLUSH(zi->z_filefunc,zi->filestream);
  1197.     else
  1198.       return EOF;
  1199. }
  1200.